home *** CD-ROM | disk | FTP | other *** search
/ Game.EXE 2001 January / Game.EXE_01_2001.iso / demos / Blade of Darkness / data1.cab / Program_Executable_Files / Lib / PythonLib / imaplib.py < prev    next >
Encoding:
Python Source  |  2000-11-16  |  20.8 KB  |  808 lines
  1. """IMAP4 client.
  2.  
  3. Based on RFC 2060.
  4.  
  5. Author: Piers Lauder <piers@cs.su.oz.au> December 1997.
  6.  
  7. Public class:        IMAP4
  8. Public variable:    Debug
  9. Public functions:    Internaldate2tuple
  10.             Int2AP
  11.             ParseFlags
  12.             Time2Internaldate
  13. """
  14.  
  15. import re, socket, string, time, whrandom
  16.  
  17. #    Globals
  18.  
  19. CRLF = '\r\n'
  20. Debug = 0
  21. IMAP4_PORT = 143
  22. AllowedVersions = ('IMAP4REV1', 'IMAP4')    # Most recent first
  23.  
  24. #    Commands
  25.  
  26. Commands = {
  27.     # name          valid states
  28.     'APPEND':    ('AUTH', 'SELECTED'),
  29.     'AUTHENTICATE':    ('NONAUTH',),
  30.     'CAPABILITY':    ('NONAUTH', 'AUTH', 'SELECTED', 'LOGOUT'),
  31.     'CHECK':    ('SELECTED',),
  32.     'CLOSE':    ('SELECTED',),
  33.     'COPY':        ('SELECTED',),
  34.     'CREATE':    ('AUTH', 'SELECTED'),
  35.     'DELETE':    ('AUTH', 'SELECTED'),
  36.     'EXAMINE':    ('AUTH', 'SELECTED'),
  37.     'EXPUNGE':    ('SELECTED',),
  38.     'FETCH':    ('SELECTED',),
  39.     'LIST':        ('AUTH', 'SELECTED'),
  40.     'LOGIN':    ('NONAUTH',),
  41.     'LOGOUT':    ('NONAUTH', 'AUTH', 'SELECTED', 'LOGOUT'),
  42.     'LSUB':        ('AUTH', 'SELECTED'),
  43.     'NOOP':        ('NONAUTH', 'AUTH', 'SELECTED', 'LOGOUT'),
  44.     'RENAME':    ('AUTH', 'SELECTED'),
  45.     'SEARCH':    ('SELECTED',),
  46.     'SELECT':    ('AUTH', 'SELECTED'),
  47.     'STATUS':    ('AUTH', 'SELECTED'),
  48.     'STORE':    ('SELECTED',),
  49.     'SUBSCRIBE':    ('AUTH', 'SELECTED'),
  50.     'UID':        ('SELECTED',),
  51.     'UNSUBSCRIBE':    ('AUTH', 'SELECTED'),
  52.     }
  53.  
  54. #    Patterns to match server responses
  55.  
  56. Continuation = re.compile(r'\+ (?P<data>.*)')
  57. Flags = re.compile(r'.*FLAGS \((?P<flags>[^\)]*)\)')
  58. InternalDate = re.compile(r'.*INTERNALDATE "'
  59.     r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-(?P<year>[0-9][0-9][0-9][0-9])'
  60.     r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'
  61.     r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'
  62.     r'"')
  63. Literal = re.compile(r'(?P<data>.*) {(?P<size>\d+)}$')
  64. Response_code = re.compile(r'\[(?P<type>[A-Z-]+)( (?P<data>[^\]]*))?\]')
  65. Untagged_response = re.compile(r'\* (?P<type>[A-Z-]+) (?P<data>.*)')
  66. Untagged_status = re.compile(r'\* (?P<data>\d+) (?P<type>[A-Z-]+)( (?P<data2>.*))?')
  67.  
  68.  
  69.  
  70. class IMAP4:
  71.  
  72.     """IMAP4 client class.
  73.  
  74.     Instantiate with: IMAP4([host[, port]])
  75.  
  76.         host - host's name (default: localhost);
  77.         port - port number (default: standard IMAP4 port).
  78.  
  79.     All IMAP4rev1 commands are supported by methods of the same
  80.     name (in lower-case). Each command returns a tuple: (type, [data, ...])
  81.     where 'type' is usually 'OK' or 'NO', and 'data' is either the
  82.     text from the tagged response, or untagged results from command.
  83.  
  84.     Errors raise the exception class <instance>.error("<reason>").
  85.     IMAP4 server errors raise <instance>.abort("<reason>"),
  86.     which is a sub-class of 'error'.
  87.     """
  88.  
  89.     class error(Exception): pass    # Logical errors - debug required
  90.     class abort(error): pass    # Service errors - close and retry
  91.  
  92.  
  93.     def __init__(self, host = '', port = IMAP4_PORT):
  94.         self.host = host
  95.         self.port = port
  96.         self.debug = Debug
  97.         self.state = 'LOGOUT'
  98.         self.tagged_commands = {}    # Tagged commands awaiting response
  99.         self.untagged_responses = {}    # {typ: [data, ...], ...}
  100.         self.continuation_response = ''    # Last continuation response
  101.         self.tagnum = 0
  102.  
  103.         # Open socket to server.
  104.  
  105.         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  106.         self.sock.connect(self.host, self.port)
  107.         self.file = self.sock.makefile('r')
  108.  
  109.         # Create unique tag for this session,
  110.         # and compile tagged response matcher.
  111.  
  112.         self.tagpre = Int2AP(whrandom.random()*32000)
  113.         self.tagre = re.compile(r'(?P<tag>'
  114.                 + self.tagpre
  115.                 + r'\d+) (?P<type>[A-Z]+) (?P<data>.*)')
  116.  
  117.         # Get server welcome message,
  118.         # request and store CAPABILITY response.
  119.  
  120.         if __debug__ and self.debug >= 1:
  121.             print '\tnew IMAP4 connection, tag=%s' % self.tagpre
  122.  
  123.         self.welcome = self._get_response()
  124.         if self.untagged_responses.has_key('PREAUTH'):
  125.             self.state = 'AUTH'
  126.         elif self.untagged_responses.has_key('OK'):
  127.             self.state = 'NONAUTH'
  128. #        elif self.untagged_responses.has_key('BYE'):
  129.         else:
  130.             raise self.error(self.welcome)
  131.  
  132.         cap = 'CAPABILITY'
  133.         self._simple_command(cap)
  134.         if not self.untagged_responses.has_key(cap):
  135.             raise self.error('no CAPABILITY response from server')
  136.         self.capabilities = tuple(string.split(self.untagged_responses[cap][-1]))
  137.  
  138.         if __debug__ and self.debug >= 3:
  139.             print '\tCAPABILITIES: %s' % `self.capabilities`
  140.  
  141.         self.PROTOCOL_VERSION = None
  142.         for version in AllowedVersions:
  143.             if not version in self.capabilities:
  144.                 continue
  145.             self.PROTOCOL_VERSION = version
  146.             break
  147.         if not self.PROTOCOL_VERSION:
  148.             raise self.error('server not IMAP4 compliant')
  149.  
  150.  
  151.     def __getattr__(self, attr):
  152.         """Allow UPPERCASE variants of all following IMAP4 commands."""
  153.         if Commands.has_key(attr):
  154.             return eval("self.%s" % string.lower(attr))
  155.         raise AttributeError("Unknown IMAP4 command: '%s'" % attr)
  156.  
  157.  
  158.     #    Public methods
  159.  
  160.  
  161.     def append(self, mailbox, flags, date_time, message):
  162.         """Append message to named mailbox.
  163.  
  164.         (typ, [data]) = <instance>.append(mailbox, flags, date_time, message)
  165.         """
  166.         name = 'APPEND'
  167.         if flags:
  168.             flags = '(%s)' % flags
  169.         else:
  170.             flags = None
  171.         if date_time:
  172.             date_time = Time2Internaldate(date_time)
  173.         else:
  174.             date_time = None
  175.         tag = self._command(name, mailbox, flags, date_time, message)
  176.         return self._command_complete(name, tag)
  177.  
  178.  
  179.     def authenticate(self, func):
  180.         """Authenticate command - requires response processing.
  181.  
  182.         UNIMPLEMENTED
  183.         """
  184.         raise self.error('UNIMPLEMENTED')
  185.  
  186.  
  187.     def check(self):
  188.         """Checkpoint mailbox on server.
  189.  
  190.         (typ, [data]) = <instance>.check()
  191.         """
  192.         return self._simple_command('CHECK')
  193.  
  194.  
  195.     def close(self):
  196.         """Close currently selected mailbox.
  197.  
  198.         Deleted messages are removed from writable mailbox.
  199.         This is the recommended command before 'LOGOUT'.
  200.  
  201.         (typ, [data]) = <instance>.close()
  202.         """
  203.         try:
  204.             try: typ, dat = self._simple_command('CLOSE')
  205.             except EOFError: typ, dat = None, [None]
  206.         finally:
  207.             self.state = 'AUTH'
  208.         return typ, dat
  209.  
  210.  
  211.     def copy(self, message_set, new_mailbox):
  212.         """Copy 'message_set' messages onto end of 'new_mailbox'.
  213.  
  214.         (typ, [data]) = <instance>.copy(message_set, new_mailbox)
  215.         """
  216.         return self._simple_command('COPY', message_set, new_mailbox)
  217.  
  218.  
  219.     def create(self, mailbox):
  220.         """Create new mailbox.
  221.  
  222.         (typ, [data]) = <instance>.create(mailbox)
  223.         """
  224.         return self._simple_command('CREATE', mailbox)
  225.  
  226.  
  227.     def delete(self, mailbox):
  228.         """Delete old mailbox.
  229.  
  230.         (typ, [data]) = <instance>.delete(mailbox)
  231.         """
  232.         return self._simple_command('DELETE', mailbox)
  233.  
  234.  
  235.     def expunge(self):
  236.         """Permanently remove deleted items from selected mailbox.
  237.  
  238.         Generates 'EXPUNGE' response for each deleted message.
  239.  
  240.         (typ, [data]) = <instance>.expunge()
  241.  
  242.         'data' is list of 'EXPUNGE'd message numbers in order received.
  243.         """
  244.         name = 'EXPUNGE'
  245.         typ, dat = self._simple_command(name)
  246.         return self._untagged_response(typ, name)
  247.  
  248.  
  249.     def fetch(self, message_set, message_parts):
  250.         """Fetch (parts of) messages.
  251.  
  252.         (typ, [data, ...]) = <instance>.fetch(message_set, message_parts)
  253.  
  254.         'data' are tuples of message part envelope and data.
  255.         """
  256.         name = 'FETCH'
  257.         typ, dat = self._simple_command(name, message_set, message_parts)
  258.         return self._untagged_response(typ, name)
  259.  
  260.  
  261.     def list(self, directory='""', pattern='*'):
  262.         """List mailbox names in directory matching pattern.
  263.  
  264.         (typ, [data]) = <instance>.list(directory='""', pattern='*')
  265.  
  266.         'data' is list of LIST responses.
  267.         """
  268.         name = 'LIST'
  269.         typ, dat = self._simple_command(name, directory, pattern)
  270.         return self._untagged_response(typ, name)
  271.  
  272.  
  273.     def login(self, user, password):
  274.         """Identify client using plaintext password.
  275.  
  276.         (typ, [data]) = <instance>.list(user, password)
  277.         """
  278.         if not 'AUTH=LOGIN' in self.capabilities \
  279.         and not 'AUTH-LOGIN' in self.capabilities:
  280.             raise self.error("server doesn't allow LOGIN authorisation")
  281.         typ, dat = self._simple_command('LOGIN', user, password)
  282.         if typ != 'OK':
  283.             raise self.error(dat)
  284.         self.state = 'AUTH'
  285.         return typ, dat
  286.  
  287.  
  288.     def logout(self):
  289.         """Shutdown connection to server.
  290.  
  291.         (typ, [data]) = <instance>.logout()
  292.  
  293.         Returns server 'BYE' response.
  294.         """
  295.         self.state = 'LOGOUT'
  296.         try: typ, dat = self._simple_command('LOGOUT')
  297.         except EOFError: typ, dat = None, [None]
  298.         self.file.close()
  299.         self.sock.close()
  300.         if self.untagged_responses.has_key('BYE'):
  301.             return 'BYE', self.untagged_responses['BYE']
  302.         return typ, dat
  303.  
  304.  
  305.     def lsub(self, directory='""', pattern='*'):
  306.         """List 'subscribed' mailbox names in directory matching pattern.
  307.  
  308.         (typ, [data, ...]) = <instance>.lsub(directory='""', pattern='*')
  309.  
  310.         'data' are tuples of message part envelope and data.
  311.         """
  312.         name = 'LSUB'
  313.         typ, dat = self._simple_command(name, directory, pattern)
  314.         return self._untagged_response(typ, name)
  315.  
  316.  
  317.     def recent(self):
  318.         """Prompt server for an update.
  319.  
  320.         (typ, [data]) = <instance>.recent()
  321.  
  322.         'data' is None if no new messages,
  323.         else value of RECENT response.
  324.         """
  325.         name = 'RECENT'
  326.         typ, dat = self._untagged_response('OK', name)
  327.         if dat[-1]:
  328.             return typ, dat
  329.         typ, dat = self._simple_command('NOOP')
  330.         return self._untagged_response(typ, name)
  331.  
  332.  
  333.     def rename(self, oldmailbox, newmailbox):
  334.         """Rename old mailbox name to new.
  335.  
  336.         (typ, data) = <instance>.rename(oldmailbox, newmailbox)
  337.         """
  338.         return self._simple_command('RENAME', oldmailbox, newmailbox)
  339.  
  340.  
  341.     def response(self, code):
  342.         """Return data for response 'code' if received, or None.
  343.  
  344.         (code, [data]) = <instance>.response(code)
  345.         """
  346.         return code, self.untagged_responses.get(code, [None])
  347.  
  348.  
  349.     def search(self, charset, criteria):
  350.         """Search mailbox for matching messages.
  351.  
  352.         (typ, [data]) = <instance>.search(charset, criteria)
  353.  
  354.         'data' is space separated list of matching message numbers.
  355.         """
  356.         name = 'SEARCH'
  357.         if charset:
  358.             charset = 'CHARSET ' + charset
  359.         typ, dat = self._simple_command(name, charset, criteria)
  360.         return self._untagged_response(typ, name)
  361.  
  362.  
  363.     def select(self, mailbox='INBOX', readonly=None):
  364.         """Select a mailbox.
  365.  
  366.         (typ, [data]) = <instance>.select(mailbox='INBOX', readonly=None)
  367.  
  368.         'data' is count of messages in mailbox ('EXISTS' response).
  369.         """
  370.         # Mandated responses are ('FLAGS', 'EXISTS', 'RECENT', 'UIDVALIDITY')
  371.         # Remove immediately interesting responses
  372.         for r in ('EXISTS', 'READ-WRITE'):
  373.             if self.untagged_responses.has_key(r):
  374.                 del self.untagged_responses[r]
  375.         if readonly:
  376.             name = 'EXAMINE'
  377.         else:
  378.             name = 'SELECT'
  379.         typ, dat = self._simple_command(name, mailbox)
  380.         if typ == 'OK':
  381.             self.state = 'SELECTED'
  382.         elif typ == 'NO':
  383.             self.state = 'AUTH'
  384.         if not readonly and not self.untagged_responses.has_key('READ-WRITE'):
  385.             raise self.error('%s is not writable' % mailbox)
  386.         return typ, self.untagged_responses.get('EXISTS', [None])
  387.  
  388.  
  389.     def status(self, mailbox, names):
  390.         """Request named status conditions for mailbox.
  391.  
  392.         (typ, [data]) = <instance>.status(mailbox, names)
  393.         """
  394.         name = 'STATUS'
  395.         if self.PROTOCOL_VERSION == 'IMAP4':
  396.             raise self.error('%s unimplemented in IMAP4 (obtain IMAP4rev1 server, or re-code)' % name)
  397.         typ, dat = self._simple_command(name, mailbox, names)
  398.         return self._untagged_response(typ, name)
  399.  
  400.  
  401.     def store(self, message_set, command, flag_list):
  402.         """Alters flag dispositions for messages in mailbox.
  403.  
  404.         (typ, [data]) = <instance>.store(message_set, command, flag_list)
  405.         """
  406.         command = '%s %s' % (command, flag_list)
  407.         typ, dat = self._simple_command('STORE', message_set, command)
  408.         return self._untagged_response(typ, 'FETCH')
  409.  
  410.  
  411.     def subscribe(self, mailbox):
  412.         """Subscribe to new mailbox.
  413.  
  414.         (typ, [data]) = <instance>.subscribe(mailbox)
  415.         """
  416.         return self._simple_command('SUBSCRIBE', mailbox)
  417.  
  418.  
  419.     def uid(self, command, args):
  420.         """Execute "command args" with messages identified by UID,
  421.             rather than message number.
  422.  
  423.         (typ, [data]) = <instance>.uid(command, args)
  424.  
  425.         Returns response appropriate to 'command'.
  426.         """
  427.         name = 'UID'
  428.         typ, dat = self._simple_command('UID', command, args)
  429.         if command == 'SEARCH':
  430.             name = 'SEARCH'
  431.         else:
  432.             name = 'FETCH'
  433.         typ, dat2 = self._untagged_response(typ, name)
  434.         if dat2[-1]: dat = dat2
  435.         return typ, dat
  436.  
  437.  
  438.     def unsubscribe(self, mailbox):
  439.         """Unsubscribe from old mailbox.
  440.  
  441.         (typ, [data]) = <instance>.unsubscribe(mailbox)
  442.         """
  443.         return self._simple_command('UNSUBSCRIBE', mailbox)
  444.  
  445.  
  446.     def xatom(self, name, arg1=None, arg2=None):
  447.         """Allow simple extension commands
  448.             notified by server in CAPABILITY response.
  449.  
  450.         (typ, [data]) = <instance>.xatom(name, arg1=None, arg2=None)
  451.         """
  452.         if name[0] != 'X' or not name in self.capabilities:
  453.             raise self.error('unknown extension command: %s' % name)
  454.         return self._simple_command(name, arg1, arg2)
  455.  
  456.  
  457.  
  458.     #    Private methods
  459.  
  460.  
  461.     def _append_untagged(self, typ, dat):
  462.  
  463.         if self.untagged_responses.has_key(typ):
  464.             self.untagged_responses[typ].append(dat)
  465.         else:
  466.             self.untagged_responses[typ] = [dat]
  467.  
  468.         if __debug__ and self.debug >= 5:
  469.             print '\tuntagged_responses[%s] += %.20s..' % (typ, `dat`)
  470.  
  471.  
  472.     def _command(self, name, dat1=None, dat2=None, dat3=None, literal=None):
  473.  
  474.         if self.state not in Commands[name]:
  475.             raise self.error(
  476.             'command %s illegal in state %s' % (name, self.state))
  477.  
  478.         tag = self._new_tag()
  479.         data = '%s %s' % (tag, name)
  480.         for d in (dat1, dat2, dat3):
  481.             if d is not None: data = '%s %s' % (data, d)
  482.         if literal is not None:
  483.             data = '%s {%s}' % (data, len(literal))
  484.  
  485.         try:
  486.             self.sock.send('%s%s' % (data, CRLF))
  487.         except socket.error, val:
  488.             raise self.abort('socket error: %s' % val)
  489.  
  490.         if __debug__ and self.debug >= 4:
  491.             print '\t> %s' % data
  492.  
  493.         if literal is None:
  494.             return tag
  495.  
  496.         # Wait for continuation response
  497.  
  498.         while self._get_response():
  499.             if self.tagged_commands[tag]:    # BAD/NO?
  500.                 return tag
  501.  
  502.         # Send literal
  503.  
  504.         if __debug__ and self.debug >= 4:
  505.             print '\twrite literal size %s' % len(literal)
  506.  
  507.         try:
  508.             self.sock.send(literal)
  509.             self.sock.send(CRLF)
  510.         except socket.error, val:
  511.             raise self.abort('socket error: %s' % val)
  512.  
  513.         return tag
  514.  
  515.  
  516.     def _command_complete(self, name, tag):
  517.         try:
  518.             typ, data = self._get_tagged_response(tag)
  519.         except self.abort, val:
  520.             raise self.abort('command: %s => %s' % (name, val))
  521.         except self.error, val:
  522.             raise self.error('command: %s => %s' % (name, val))
  523.         if self.untagged_responses.has_key('BYE') and name != 'LOGOUT':
  524.             raise self.abort(self.untagged_responses['BYE'][-1])
  525.         if typ == 'BAD':
  526.             raise self.error('%s command error: %s %s' % (name, typ, data))
  527.         return typ, data
  528.  
  529.  
  530.     def _get_response(self):
  531.  
  532.         # Read response and store.
  533.         #
  534.         # Returns None for continuation responses,
  535.         # otherwise first response line received
  536.  
  537.         # Protocol mandates all lines terminated by CRLF.
  538.  
  539.         resp = self._get_line()[:-2]
  540.  
  541.         # Command completion response?
  542.  
  543.         if self._match(self.tagre, resp):
  544.             tag = self.mo.group('tag')
  545.             if not self.tagged_commands.has_key(tag):
  546.                 raise self.abort('unexpected tagged response: %s' % resp)
  547.  
  548.             typ = self.mo.group('type')
  549.             dat = self.mo.group('data')
  550.             self.tagged_commands[tag] = (typ, [dat])
  551.         else:
  552.             dat2 = None
  553.  
  554.             # '*' (untagged) responses?
  555.  
  556.             if not self._match(Untagged_response, resp):
  557.                 if self._match(Untagged_status, resp):
  558.                     dat2 = self.mo.group('data2')
  559.  
  560.             if self.mo is None:
  561.                 # Only other possibility is '+' (continuation) rsponse...
  562.  
  563.                 if self._match(Continuation, resp):
  564.                     self.continuation_response = self.mo.group('data')
  565.                     return None    # NB: indicates continuation
  566.  
  567.                 raise self.abort('unexpected response: %s' % resp)
  568.  
  569.             typ = self.mo.group('type')
  570.             dat = self.mo.group('data')
  571.             if dat2: dat = dat + ' ' + dat2
  572.  
  573.             # Is there a literal to come?
  574.  
  575.             while self._match(Literal, dat):
  576.  
  577.                 # Read literal direct from connection.
  578.  
  579.                 size = string.atoi(self.mo.group('size'))
  580.                 if __debug__ and self.debug >= 4:
  581.                     print '\tread literal size %s' % size
  582.                 data = self.file.read(size)
  583.  
  584.                 # Store response with literal as tuple
  585.  
  586.                 self._append_untagged(typ, (dat, data))
  587.  
  588.                 # Read trailer - possibly containing another literal
  589.  
  590.                 dat = self._get_line()[:-2]
  591.  
  592.             self._append_untagged(typ, dat)
  593.  
  594.         # Bracketed response information?
  595.  
  596.         if typ in ('OK', 'NO', 'BAD') and self._match(Response_code, dat):
  597.             self._append_untagged(self.mo.group('type'), self.mo.group('data'))
  598.  
  599.         return resp
  600.  
  601.  
  602.     def _get_tagged_response(self, tag):
  603.  
  604.         while 1:
  605.             result = self.tagged_commands[tag]
  606.             if result is not None:
  607.                 del self.tagged_commands[tag]
  608.                 return result
  609.             self._get_response()
  610.  
  611.  
  612.     def _get_line(self):
  613.  
  614.         line = self.file.readline()
  615.         if not line:
  616.             raise EOFError
  617.  
  618.         # Protocol mandates all lines terminated by CRLF
  619.  
  620.         if __debug__ and self.debug >= 4:
  621.             print '\t< %s' % line[:-2]
  622.         return line
  623.  
  624.  
  625.     def _match(self, cre, s):
  626.  
  627.         # Run compiled regular expression match method on 's'.
  628.         # Save result, return success.
  629.  
  630.         self.mo = cre.match(s)
  631.         if __debug__ and self.mo is not None and self.debug >= 5:
  632.             print "\tmatched r'%s' => %s" % (cre.pattern, `self.mo.groups()`)
  633.         return self.mo is not None
  634.  
  635.  
  636.     def _new_tag(self):
  637.  
  638.         tag = '%s%s' % (self.tagpre, self.tagnum)
  639.         self.tagnum = self.tagnum + 1
  640.         self.tagged_commands[tag] = None
  641.         return tag
  642.  
  643.  
  644.     def _simple_command(self, name, dat1=None, dat2=None):
  645.  
  646.         return self._command_complete(name, self._command(name, dat1, dat2))
  647.  
  648.  
  649.     def _untagged_response(self, typ, name):
  650.  
  651.         if not self.untagged_responses.has_key(name):
  652.             return typ, [None]
  653.         data = self.untagged_responses[name]
  654.         del self.untagged_responses[name]
  655.         return typ, data
  656.  
  657.  
  658.  
  659. Mon2num = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
  660.     'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
  661.  
  662. def Internaldate2tuple(resp):
  663.  
  664.     """Convert IMAP4 INTERNALDATE to UT.
  665.  
  666.     Returns Python time module tuple.
  667.     """
  668.  
  669.     mo = InternalDate.match(resp)
  670.     if not mo:
  671.         return None
  672.  
  673.     mon = Mon2num[mo.group('mon')]
  674.     zonen = mo.group('zonen')
  675.  
  676.     for name in ('day', 'year', 'hour', 'min', 'sec', 'zoneh', 'zonem'):
  677.         exec "%s = string.atoi(mo.group('%s'))" % (name, name)
  678.  
  679.     # INTERNALDATE timezone must be subtracted to get UT
  680.  
  681.     zone = (zoneh*60 + zonem)*60
  682.     if zonen == '-':
  683.         zone = -zone
  684.  
  685.     tt = (year, mon, day, hour, min, sec, -1, -1, -1)
  686.  
  687.     utc = time.mktime(tt)
  688.  
  689.     # Following is necessary because the time module has no 'mkgmtime'.
  690.     # 'mktime' assumes arg in local timezone, so adds timezone/altzone.
  691.  
  692.     lt = time.localtime(utc)
  693.     if time.daylight and lt[-1]:
  694.         zone = zone + time.altzone
  695.     else:
  696.         zone = zone + time.timezone
  697.  
  698.     return time.localtime(utc - zone)
  699.  
  700.  
  701.  
  702. def Int2AP(num):
  703.  
  704.     """Convert integer to A-P string representation."""
  705.  
  706.     val = ''; AP = 'ABCDEFGHIJKLMNOP'
  707.     num = int(abs(num))
  708.     while num:
  709.         num, mod = divmod(num, 16)
  710.         val = AP[mod] + val
  711.     return val
  712.  
  713.  
  714.  
  715. def ParseFlags(resp):
  716.  
  717.     """Convert IMAP4 flags response to python tuple."""
  718.  
  719.     mo = Flags.match(resp)
  720.     if not mo:
  721.         return ()
  722.  
  723.     return tuple(string.split(mo.group('flags')))
  724.  
  725.  
  726. def Time2Internaldate(date_time):
  727.  
  728.     """Convert 'date_time' to IMAP4 INTERNALDATE representation.
  729.  
  730.     Return string in form: '"DD-Mmm-YYYY HH:MM:SS +HHMM"'
  731.     """
  732.  
  733.     dttype = type(date_time)
  734.     if dttype is type(1):
  735.         tt = time.localtime(date_time)
  736.     elif dttype is type(()):
  737.         tt = date_time
  738.     elif dttype is type(""):
  739.         return date_time    # Assume in correct format
  740.     else: raise ValueError
  741.  
  742.     dt = time.strftime("%d-%b-%Y %H:%M:%S", tt)
  743.     if dt[0] == '0':
  744.         dt = ' ' + dt[1:]
  745.     if time.daylight and tt[-1]:
  746.         zone = -time.altzone
  747.     else:
  748.         zone = -time.timezone
  749.     return '"' + dt + " %+02d%02d" % divmod(zone/60, 60) + '"'
  750.  
  751.  
  752.  
  753. if __debug__ and __name__ == '__main__':
  754.  
  755.     import getpass
  756.     USER = getpass.getuser()
  757.     PASSWD = getpass.getpass()
  758.  
  759.     test_seq1 = (
  760.     ('login', (USER, PASSWD)),
  761.     ('create', ('/tmp/xxx',)),
  762.     ('rename', ('/tmp/xxx', '/tmp/yyy')),
  763.     ('CREATE', ('/tmp/yyz',)),
  764.     ('append', ('/tmp/yyz', None, None, 'From: anon@x.y.z\n\ndata...')),
  765.     ('select', ('/tmp/yyz',)),
  766.     ('recent', ()),
  767.     ('uid', ('SEARCH', 'ALL')),
  768.     ('fetch', ('1', '(INTERNALDATE RFC822)')),
  769.     ('store', ('1', 'FLAGS', '(\Deleted)')),
  770.     ('expunge', ()),
  771.     ('close', ()),
  772.     )
  773.  
  774.     test_seq2 = (
  775.     ('select', ()),
  776.     ('response',('UIDVALIDITY',)),
  777.     ('uid', ('SEARCH', 'ALL')),
  778.     ('recent', ()),
  779.     ('response', ('EXISTS',)),
  780.     ('logout', ()),
  781.     )
  782.  
  783.     def run(cmd, args):
  784.         typ, dat = apply(eval('M.%s' % cmd), args)
  785.         print ' %s %s\n  => %s %s' % (cmd, args, typ, dat)
  786.         return dat
  787.  
  788.     Debug = 4
  789.     M = IMAP4()
  790.     print 'PROTOCOL_VERSION = %s' % M.PROTOCOL_VERSION
  791.  
  792.     for cmd,args in test_seq1:
  793.         run(cmd, args)
  794.  
  795.     for ml in run('list', ('/tmp/', 'yy%')):
  796.         path = string.split(ml)[-1]
  797.         run('delete', (path,))
  798.  
  799.     for cmd,args in test_seq2:
  800.         dat = run(cmd, args)
  801.  
  802.         if (cmd,args) != ('uid', ('SEARCH', 'ALL')):
  803.             continue
  804.  
  805.         uid = string.split(dat[0])[-1]
  806.         run('uid', ('FETCH',
  807.             '%s (FLAGS INTERNALDATE RFC822.SIZE RFC822.HEADER RFC822)' % uid))
  808.